home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 16 / AMIGAplus Sonderheft 16 (1998)(ICP)(DE)[!].iso / pd / anwendungen / rtgmaster_dev / devdocs / rtgmaster.ad < prev    next >
Text File  |  1998-06-29  |  84KB  |  2,124 lines
  1. rtgmaster.library/CallRtgC2P                                rtgmaster.library/CallRtgC2P
  2.  
  3.    NAME
  4.         CallRtgC2P -- Perform c2p for Planar Screens, CopyRtgPixelArray for Chunky Screens
  5.  
  6.    SYNOPSIS
  7.         int CallRtgC2P(RtgScreen,BufAdr,Array,signal,xpos,ypos,width,height,mode)
  8.          D0              A0        A1     A2    D0     D1   D2   D3    D4     D5
  9.  
  10.         int CallRtgC2P(struct RtgScreen *,APTR,APTR,ULONG,ULONG,ULONG,ULONG,ULONG,ULONG)
  11.  
  12.    FUNCTION
  13.         This function will look what the "standard c2p" for the system is up to now
  14.         (the standard c2p can be choose by a future version of the Rtgmaster Screenmode
  15.         requester, the available c2p algorithms are found in libs:rtgc2p, how own c2p
  16.         algorithms can be added to the system will be explained in the documentation
  17.         of the first version of rtgmaster.library that actually supports CallRtgC2P).
  18.         The function will, if the display is a Planar one, convert the Chunky Data in
  19.         Array to Planar using the choosen c2p algorithm, and display it in the choosen
  20.         Buffer. For Chunky Displays it will instead do the same as CopyRtgChunkyPixel.
  21.         This way a very easy possibility to support both AGA and Graphics Boards without
  22.         having to do "special versions" will be available, if one uses a Fastram Buffer.
  23.  
  24.         I am still looking for c2p algorithms for this function !!! All used c2p algorithms
  25.         should support AGA and additional, it would be fine, if they supported
  26.         1x1,1x2,2x1 and 2x2. If you have fine c2p algorithms, mail me
  27.         (MagicSN@birdland.es.bawue.de).
  28.  
  29.         NOTE : The Array should EXACTLY be as big as specified with Left, Top, Width
  30.         and Height... it should *NOT* be bigger.
  31.  
  32.         NOTE: Currently you *HAVE TO* use xpos=0 ypos=0 width=<max x> height=<max y>
  33.         Maybe this will change in the future !!!!!!!!!!!!!! This is only because i do
  34.         not have ANY c2p that supports that feature up to now...
  35.  
  36.         NOTE: Some c2p algorithms might do NOTHING in certain colour depths, chunky modes
  37.         or for interleaved bitmaps. Be careful about this. If the c2p works,
  38.         this function returns 0, otherwise an errorcode.
  39.  
  40.         Principially it COULD support 256, 64 (EHB), 32 or 16 colors and 1x1, 1x2, 2x1,
  41.         2x2,4x2,2x4 and 4x4 (look at the includes). It is also possible to choose the
  42.         FASTEST AVAILABLE, the BEST AVAILABLE mode or the mode that was selected from
  43.         the user as standard mode for his system, using the Screenmode Requester.
  44.  
  45.         If the user did not specify a standard c2p, this function will use the fastest
  46.         available mode.
  47.  
  48.         The signal indicates (for asynchrone c2p) that the c2p has done. For synchrone
  49.         ones it is set after quitting the function.
  50.  
  51.         In mode you specify which c2p mode to use.
  52.  
  53.         For Graphics Boards, ALWAYS 1x1 is used.
  54.  
  55.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 2.0 (none up to now...)
  56.  
  57.    INPUTS
  58.         RtgScreen - The RtgScreen to use.
  59.         BufAdr - The address of the buffer to use
  60.         Array - The fastram buffer
  61.         Left - The x position on the Bitmap of RtgScreen where to put the stuff
  62.         Top - The y position
  63.         Width - The Width of the stuff
  64.         Height - The Height of the stuff
  65.  
  66.    SEE ALSO
  67.         CopyRtgPixelArray()
  68.  
  69. rtgmaster.library/CloseClient                               rtgmaster.library/CloseClient
  70.  
  71.    NAME
  72.         CloseClient -- Closes the Client of a TCP/IP connection again
  73.  
  74.    SYNOPSIS
  75.         CloseClient(SBase,Socket)
  76.                      A0    A1
  77.  
  78.         CloseClient(struct Library *,struct TCP_Socket *)
  79.  
  80.    FUNCTION
  81.         Terminates a "virtual connection" of TCP/IP and gives the Socket of the Client
  82.         back to the system. (For UDP it only gives the socket back to the system,
  83.         as there are no "virtual connections" in connectionless UDP).
  84.  
  85.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  86.         yourselves and provide it as parameter. This is needed because of some internal
  87.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  88.         at the Docs for more information.
  89.  
  90.         You do NOT have to use rtgmaster.library's Graphics Board features to
  91.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  92.  
  93.    INPUTS
  94.         SBase    - Result of the call (C Syntax here...)
  95.                    SBase = OpenLibrary("bsdsocket.library",0);
  96.         Socket   - The Socket of the Client you want to close.
  97.                    You should ONLY use this function for Clients,
  98.                    NOT FOR SERVERS !!!
  99.  
  100.  SEE ALSO
  101.         OpenClient(),OpenServer(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  102.  
  103. rtgmaster.library/CloseRtgScreen                            rtgmaster.library/CloseRtgScreen
  104.  
  105.    NAME
  106.         CloseRtgScreen -- Close a screen previously opened with
  107.                           OpenRtgScreen
  108.  
  109.    SYNOPSIS
  110.         CloseRtgScreen(RtgScreen)
  111.                         A0
  112.  
  113.         CloseRtgScreen(ULONG)
  114.  
  115.    FUNCTION
  116.         Should close a RtgScreen opened by this sublibrary and free all
  117.         of its resources.
  118.  
  119.    INPUTS
  120.         RtgScreen - A handle for a valid screen previously opened by
  121.                     this sublibrary's OpenRtgScreen() function.
  122.  
  123.    SEE ALSO
  124.         OpenRtgScreen()
  125.  
  126. rtgmaster.library/CloseServer                               rtgmaster.library/CloseServer
  127.  
  128.    NAME
  129.         CloseServer -- Closes the Server of a TCP/IP connection again
  130.  
  131.    SYNOPSIS
  132.         CloseServer(SBase,Socket)
  133.                      A0    A1
  134.  
  135.         CloseServer(struct Library *,struct TCP_Socket *)
  136.  
  137.    FUNCTION
  138.         Terminates a "virtual connection" of TCP/IP and gives the Socket of the Server
  139.         back to the system. For UDP it only gives the socket back to the system, as
  140.         for UDP there is no connection to terminate.
  141.  
  142.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  143.         yourselves and provide it as parameter. This is needed because of some internal
  144.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  145.         at the Docs for more information.
  146.  
  147.         You do NOT have to use rtgmaster.library's Graphics Board features to
  148.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  149.  
  150.    INPUTS
  151.         SBase    - Result of the call (C Syntax here...)
  152.                    SBase = OpenLibrary("bsdsocket.library",0);
  153.         Socket   - The Socket of the Client you want to close.
  154.                    You should ONLY use this function for Servers,
  155.                    NOT FOR CLIENTS !!!
  156.  
  157.  SEE ALSO
  158.         OpenClient(),OpenServer(),CloseClient(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  159.  
  160. rtgmaster.library/CopyRtgBlit                            rtgmaster.library/CopyRtgBlit
  161.  
  162.    NAME
  163.         CopyRtgBlit -- Copy a rectangular array of pixels without conversion, with
  164.                        Modulo support and c2p support
  165.  
  166.    SYNOPSIS
  167.         CopyRtgBlit(RtgScreen, BufferAdr, Array, Masked. Left, Top, Width, Height, WidthSrc, HeightSrc, SrcX, SrcY)
  168.                      A0         A1         A2     A3      D0    D1   D2     D3      D4        D5         D6    D7
  169.  
  170.         CopyRtgBlit(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  171.                     ULONG,ULONG,ULONG,ULONG,ULONG,ULONG)
  172.  
  173.    FUNCTION
  174.         Nearly the same like CopyRtgPixelArray, but also has Modulo Support. Additionally,
  175.         it provides c2p for ECS/AGA, while CopyRtgPixelArray works in Planar Mode for
  176.         ECS/AGA. CopyRtgBlit does only support synchronous c2p, as signalling would
  177.         slow down the function a bit. It is faster than CallRtgC2P. In case of a
  178.         asynchrone c2p being chosen, it uses a default synchronous c2p algorithm.
  179.         In fact it is adviced to use this function, the old ones are mainly provided
  180.         for backward compatibility. Masked feature not yet implemented for AGA.
  181.  
  182.    INPUTS
  183.         RtgScreen - The RtgScreen to use
  184.         BufferAdr - The Video RAM Base Address to use
  185.         Array     - The Source Array
  186.         Masked    - If Masked == 1, only pixels != color 0 will be overwritten
  187.         Left      - The Destination X Offset
  188.         Top       - The Destination Y Offset
  189.         Width     - The Width of the Blit
  190.         Height    - The Height of the Blit
  191.         WidthSrc  - The Width of the Source
  192.         HeightSrc - The Height of the Source
  193.         SrcX      - The Source X Offset
  194.         SrcY      - The Source Y Offset
  195.  
  196.    SEE ALSO
  197.         CopyRtgPixelArray(), CallRtgC2P()
  198.  
  199. rtgmaster.library/CopyRtgPixelArray                      rtgmaster.library/CopyRtgPixelArray
  200.  
  201.    NAME
  202.         CopyRtgPixelArray -- Copy a rectangular array of pixels directly
  203.                              to the graphics card memory without any
  204.                              conversion
  205.  
  206.    SYNOPSIS
  207.         CopyRtgPixelArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height,SrcX,SrcY
  208.                            A0         A1         A2     D0    D1   D2     D3     D4   D5
  209.  
  210.         CopyRtgPixelArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  211.                           ULONG, ULONG,ULONG,ULONG)
  212.  
  213.    FUNCTION
  214.         Copies a rectangular array of pixels directly to the graphics card
  215.         memory with no conversion.  The array of pixels is assumed to be
  216.         in the correct native format so it can be copied at maximum speed.
  217.         The copy routine however does take segment boundaries in account (if
  218.         required).
  219.  
  220.         This routine is mainly intended for machines which have relatively
  221.         fast FastRAM compared to the speed of the graphics card RAM.  This
  222.         is usually on machines with a 32-bit accelerator card which have
  223.         a Zorro-II graphics card installed.
  224.  
  225.         Note: For compatibility with rtgAMI.library,
  226.         Array should contain at least ((((width+15)>>4)<<4)*Height Bytes.
  227.  
  228.         NOT YET IMPLEMENTED ON ECS/AGA. SrcX and SrcY not yet implemented.
  229.  
  230.    INPUTS
  231.         RtgScreen - A handle for a valid screen previously opened by
  232.                     this sublibrary's OpenRtgScreen() function.
  233.         BufferAdr - The address of the memory containing the actual
  234.                     screen graphics
  235.         Array - Pointer to an array of pixels which is Width pixels wide,
  236.                 and Height pixels high.  The size of the pixel is dependant
  237.                 on the ScreenBuffer your copying to.  Make sure the array
  238.                 is in the correct native format.
  239.         Left - X position of the top-left of the rectangular pixel array
  240.         Top - Y position of the top-left of the rectangular pixel array
  241.         Width - Width of the array in pixels
  242.         Height - Height of the array in pixels
  243.  
  244.    SEE ALSO
  245.         OpenRtgScreen(), WritePixelArray(), WritePixelRGBArray()
  246.  
  247.  
  248. rtgmaster.library/DrawRtgLine                                   rtgmaster.library/DrawRtgLine
  249.  
  250.    NAME
  251.         DrawRtgLine - draws a line on a RtgScreen
  252.  
  253.    SYNOPSIS
  254.         DrawRtgLine(RtgScreen, BufferAdr, Color, X1, Y1, X2, Y2)
  255.                      A0         A1         D0     D1  D2  D3  D4
  256.  
  257.         DrawRtgLine(struct RtgScreen *, APTR, ULONG, LONG, LONG, LONG, LONG)
  258.  
  259.    FUNCTION
  260.         Draws a line on the screen which will be clipped if necessary.
  261.         NOTE : X1<=X2 AND Y1<=Y2 !!!
  262.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  263.  
  264.    INPUTS
  265.         RtgScreen - A handle for a valid screen previously opened by
  266.                     this sublibrary's OpenRtgScreen() function.
  267.         BufferAdr - The address of the memory containing the actual
  268.                     screen graphics
  269.         Color - Color number
  270.         X1,Y1,X2,Y2 - Draws a line from (X1,Y1) to (X2,Y2)
  271.  
  272.    SEE ALSO
  273.         OpenRtgScreen(), DrawRtgLineRGB()
  274.  
  275.  
  276. rtgmaster.library/DrawRtgLineRGB                             rtgmaster.library/DrawRtgLineRGB
  277.  
  278.    NAME
  279.         DrawRtgLineRGB - draws a line on a RtgScreen
  280.  
  281.    SYNOPSIS
  282.         DrawRtgLineRGB(RtgScreen, BufferAdr, Color, X1, Y1, X2, Y2)
  283.                         A0         A1         D0     D1  D2  D3  D4
  284.  
  285.         DrawRtgLineRGB(struct RtgScreen *, APTR, ULONG, LONG, LONG, LONG,
  286.                        LONG)
  287.  
  288.    FUNCTION
  289.         Draws a line on the screen which will be clipped if necessary.
  290.         NOTE: X1<=X2 AND Y1<=Y2 !!!
  291.  
  292.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  293.  
  294.    INPUTS
  295.         RtgScreen - A handle for a valid screen previously opened by
  296.                     this sublibrary's OpenRtgScreen() function.
  297.         BufferAdr - The address of the memory containing the actual
  298.                     screen graphics
  299.         Color - A 32-bit value describing the color
  300.         X1,Y1,X2,Y2 - Draws a line from (X1,Y1) to (X2,Y2)
  301.  
  302.    SEE ALSO
  303.         OpenRtgScreen(), DrawRtgLine()
  304.  
  305.  
  306. rtgmaster.library/FillRtgRect                                   rtgmaster.library/FillRtgRect
  307.  
  308.    NAME
  309.         FillRtgRect - draws a filled rectangle to a RtgScreen
  310.  
  311.    SYNOPSIS
  312.         FillRtgRect(RtgScreen, BufferAdr, Color, Left, Top, Width, Height)
  313.                      A0         A1         D0     D1    D2   D3     D4
  314.  
  315.         FillRtgRect(struct RtgScreen *, APTR, ULONG, ULONG, ULONG,
  316.                     ULONG, ULONG)
  317.  
  318.    FUNCTION
  319.         Draws a filled rectangle at the specified position on a RtgScreen.
  320.         The BufferAdr is the starting address of the buffer the users wants
  321.         to draw the rectangle in.  The user has obtained this address using
  322.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  323.         the correct buffer for screens which are double or triple buffered.
  324.  
  325.         This function should only work for Palette mapped modes, Color is
  326.         the Color number of the palette.
  327.  
  328.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  329.  
  330.    INPUTS
  331.         RtgScreen - A handle for a valid screen previously opened by
  332.                     this sublibrary's OpenRtgScreen() function.
  333.         BufferAdr - The address of the memory containing the actual
  334.                     screen graphics
  335.         Color - Color number
  336.         Left - X position of the top-left of the rectangle
  337.         Top - Y position of the top-left of the rectangle
  338.         Width - Width of the rectangle in pixels
  339.         Height - Height of the rectangle in pixels
  340.  
  341.    SEE ALSO
  342.         OpenRtgScreen(), FillRtgRectRGB()
  343.  
  344.  
  345.  
  346. rtgmaster.library/FillRtgRectRGB                             rtgmaster.library/FillRtgRectRGB
  347.  
  348.    NAME
  349.         FillRtgRectRGB - draws a filled rectangle to a RtgScreen
  350.  
  351.    SYNOPSIS
  352.         FillRtgRectRGB(RtgScreen, BufferAdr, Color, Left, Top, Width, Height)
  353.                         A0         A1         D0     D1    D2   D3     D4
  354.  
  355.         FillRtgRectRGB(struct RtgScreen *, APTR, ULONG, ULONG, ULONG,
  356.                        ULONG, ULONG)
  357.  
  358.    FUNCTION
  359.         Draws a filled rectangle at the specified position on a RtgScreen.
  360.         The BufferAdr is the starting address of the buffer the users wants
  361.         to draw the rectangle in.  The user has obtained this address using
  362.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  363.         the correct buffer for screens which are double or triple buffered.
  364.  
  365.         This function should only work for True Color modes, Color is
  366.         a 32 bit value which specifies what Color the pixel should be.
  367.         The layout of this 32-bit value is as follows:
  368.  
  369.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb
  370.  
  371.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  372.             user will set this to zero if the user doesn't want to use
  373.             AlphaChannel.
  374.         r = Red component (8-bits) of the 24-bit RGB value
  375.         g = Green component (8-bits) of the 24-bit RGB value
  376.         b = Blue component (8-bits) of the 24-bit RGB value
  377.  
  378.         IMPLEMENTED WITH SUBLIBRARIES WITH AT LEAST VERSION 1.9
  379.  
  380.    INPUTS
  381.         RtgScreen - A handle for a valid screen previously opened by
  382.                     this sublibrary's OpenRtgScreen() function.
  383.         BufferAdr - The address of the memory containing the actual
  384.                     screen graphics
  385.         Color - A 32-bit value describing the color (see above)
  386.         Left - X position of the top-left of the rectangle
  387.         Top - Y position of the top-left of the rectangle
  388.         Width - Width of the rectangle in pixels
  389.         Height - Height of the rectangle in pixels
  390.  
  391.    SEE ALSO
  392.         OpenRtgScreen(), FillRtgRect()
  393.  
  394. rtgmaster.library/RtgScreenModeReq                          rtgmaster.library/FreeRtgScreenModeReq
  395.  
  396.    NAME
  397.         FreeRtgScreenModeReq - frees the ScreenReq structure again
  398.  
  399.    SYNOPSIS
  400.         FreeRtgScreenModeReq(myreq)
  401.                               A0
  402.  
  403.         FreeRtgScreenModeReq(struct ScreenReq *)
  404.  
  405.    FUNCTION
  406.         This function frees the memory allocated by RtgScreenModeReq again.
  407.         Should be called after you need that data not any longer. Note: This
  408.         function caused a system crash with an early Beta Version of rtgmaster.library.
  409.         This does no longer happen, as this bug got fixed. This function is
  410.         only in the master-library, not in the sublibraries.
  411.  
  412.    INPUTS
  413.         myreq - The ScreenReq Structure returned by RtgScreenModeReq
  414.  
  415.    SEE ALSO
  416.         RtgScreenModeReq()
  417.  
  418. rtgmaster.library/FreeRtgSRList                           rtgmaster.library/RtgAllocSRList
  419.  
  420.    NAME
  421.         FreeRtgSRList - Frees a list of ScreenReq's
  422.  
  423.    SYNOPSIS
  424.         FreeRtgSRList(sr)
  425.                       A0
  426.  
  427.         FreeRtgSRList(struct ScreenReqList *)
  428.  
  429.    FUNCTION
  430.         This function frees a list of ScreenReq structures allocated by
  431.         RtgAllocSRList again.
  432.  
  433.    INPUTS
  434.         sr - the List
  435.  
  436.    SEE ALSO
  437.         RtgScreenModeReq(), FreeRtgScreenModeReq(), RtgAllocSRList()
  438.  
  439. rtgmaster.library/FreeScreenModes                           rtgmaster.library/FreeScreenModes
  440.  
  441.    NAME
  442.         FreeScreenModes - frees a list of screenmodes
  443.  
  444.    SYNOPSIS
  445.         FreeScreenModes(array of screenmodes)
  446.                          A0
  447.  
  448.         FreeScreenModes(APTR)
  449.  
  450.    FUNCTION
  451.         This function should free a previously with GetScreenModes()
  452.         allocated list of ScreenMode structures, including everything else
  453.         GetScreenModes() allocated.  Be prepared to handle a NULL pointer.
  454.         THIS FUNCTION IS ONLY IN SUBLIBRARIES, NOT IN THE MASTER-LIBRARY
  455.         ITSELF. IT IS ONLY CALLED BY RTGMASTER.LIBRARY ITSELF.
  456.  
  457.    INPUTS
  458.         array - an array of ScreenMode structures or NULL
  459.  
  460.    SEE ALSO
  461.         GetScreenModes()
  462.  
  463.  
  464.  
  465. rtgmaster.library/GetBufAdr                                       rtgmaster.library/GetBufAdr
  466.  
  467.    NAME
  468.         GetBufAdr -- Get the address for one of the buffers from a
  469.                      multi-buffered RtgScreen
  470.  
  471.    SYNOPSIS
  472.         address = GetBufAdr(RtgScreen, Buffer)
  473.          D0                  A0         D0
  474.  
  475.         APTR GetBufAdr(ULONG, ULONG)
  476.  
  477.    FUNCTION
  478.         If the user is using multi-buffered screens, it might be usefull
  479.         to know where the two buffers start in memory.  After a
  480.         LockRtgScreen() the user can call this function with a RtgScreen
  481.         handle and a number to get the address of the corresponding
  482.         buffer.
  483.  
  484.         The address is only valid if the RtgScreen is currently locked
  485.         using LockRtgScreen().
  486.  
  487.    INPUTS
  488.         RtgScreen - A handle for a valid screen previously opened by
  489.                     this sublibrary's OpenRtgScreen() function.
  490.         Buffer - The buffer number the user wants the address of
  491.  
  492.    RESULTS
  493.         address - the address of the buffer, or NULL for failure
  494.  
  495.    SEE ALSO
  496.         LockRtgScreen(), OpenRtgScreen()
  497.  
  498.  
  499. rtgmaster.library/GetRtgScreenData                        rtgmaster.library/GetRtgScreenData
  500.  
  501.    NAME
  502.         GetRtgScreenData -- Fills a TagList with data about the RtgScreen 
  503.  
  504.    SYNOPSIS
  505.         GetRtgScreenData(RtgScreen, TagList)
  506.                           A0         A1
  507.  
  508.         GetRtgScreenData(ULONG, struct TagItem *)
  509.  
  510.    FUNCTION
  511.         This function should fill the TI_DATA fields of the passed in
  512.         TagList with the requested information.
  513.  
  514.         See for available tags and descriptions in the .i/.h file.
  515.  
  516.         NOTE: Starting with sublibrary V2.2, this function can also
  517.         be used to find out to what BUSSYSTEM a Graphics Board is
  518.         connected. In the original design of rtgmaster an extra function
  519.         was intended for that, but now it is the job of GetRtgScreenData.
  520.  
  521.    INPUTS
  522.         RtgScreen - A handle for a valid screen previously opened by
  523.                     this sublibrary's OpenRtgScreen() function.
  524.         TagList - TagList which should be filled in with requested info.
  525.  
  526.    SEE ALSO
  527.         OpenRtgScreen(), GetBufAdr()
  528.  
  529.  
  530.  
  531. rtgmaster.library/GetScreenModes                             rtgmaster.library/GetScreenModes
  532.  
  533.    NAME
  534.         GetScreenModes - builds a list of available screenmodes
  535.  
  536.    SYNOPSIS
  537.         array of ScreenMode structures = GetScreenModes()
  538.          D0
  539.  
  540.         APTR GetScreenModes()
  541.  
  542.    FUNCTION
  543.         This function should return a linked list of ScreenMode structures
  544.         describing all the available ScreenModes available to this
  545.         sublibrary.  If there aren't any, or you couldn't allocate the
  546.         memory for the list then return 0. THIS FUNCTION IS ONLY IN SUBLIBRARIES,
  547.         NOT IN THE MASTER-LIBRARY ITSELF. IT IS ONLY CALLED BY RTGMASTER.LIBRARY
  548.         ITSELF.
  549.  
  550.    RESULTS
  551.         array - an array of ScreenMode structures or NULL
  552.  
  553.    SEE ALSO
  554.         FreeScreenModes()
  555.  
  556. rtgmaster.library/GetUDPName                                     rtgmaster.library/GetUDPName
  557.  
  558.    NAME
  559.         GetUDPName - Get the sockaddr_in structure of a UDP Client/Server
  560.  
  561.    SYNOPSIS
  562.         name = GetUDPName(SocketBase, sock)
  563.                     A0          A1
  564.  
  565.         struct sockaddr_in *GetUDPName(struct Library *, struct RTG_Socket *)
  566.  
  567.    FUNCTION
  568.         If this is UDP, you will get the sockaddr_in structure of a Client/Server,
  569.         else you will get 0. For what this is intended, read RtgRecv/RtgSend/RtgInAdr.
  570.         And of course the Docs of rtgmaster.library where detailed information about
  571.         TCP, IP and UDP is found.
  572.  
  573.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  574.         yourselves and provide it as parameter. This is needed because of some internal
  575.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  576.         at the Docs for more information.
  577.  
  578.         You do NOT have to use rtgmaster.library's Graphics Board features to
  579.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  580.  
  581.         Actually this function is now inside rtgextra.library
  582.  
  583.    INPUTS
  584.         SBase    - Result of the call (C Syntax here...)
  585.                    SBase = OpenLibrary("bsdsocket.library",0);
  586.         Socket   - The Socket of the Client you want to close.
  587.                    You should ONLY use this function for Clients,
  588.                    NOT FOR SERVERS !!!
  589.  
  590.    RESULTS
  591.         name     - The sockaddr_in structure of the Client/Server
  592.  
  593.  SEE ALSO
  594.         OpenClient(),OpenServer(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),RtgInAdr()
  595.  
  596. rtgmaster.library/LoadRGBRtg                                     rtgmaster.library/LoadRGBRtg
  597.  
  598.    NAME
  599.         LoadRGBRtg - changes one or more colors of a RtgScreen
  600.  
  601.    SYNOPSIS
  602.         LoadRGBRtg(RtgScreen, Table)
  603.                     A0         A1
  604.  
  605.         LoadRGBRtg(ULONG, APTR)
  606.  
  607.    FUNCTION
  608.         Enables the user to change one or more colors of his/her screen.
  609.         This function only works for RtgScreens which have a palette, and
  610.         thus won't work for the True-color modes.
  611.  
  612.    INPUTS
  613.         RtgScreen - A handle for a valid screen previously opened by
  614.                     this sublibrary's OpenRtgScreen() function.
  615.         Table - A pointer to a series of records which describe which
  616.                 colors to modify
  617.  
  618.    NOTES
  619.         Passing a NULL Table must be ignored.  The format of the Table
  620.         passed is a series of records, each with the this format:
  621.  
  622.            WORD  Count value: Number of colors to load
  623.            WORD  Number of first color to be loaded
  624.  
  625.         After these two words, a list of 3 Longs follow as many times
  626.         as specified by the first word.  These 3 longwords represent the
  627.         left justified 32 bit RGB value.
  628.  
  629.         And then the list repeats until ended with a count value of 0.
  630.  
  631.         See for more information about the table graphics/LoadRGB32.
  632.         This function must use the same format.
  633.  
  634.    SEE ALSO
  635.         OpenRtgScreen(), graphics/LoadRGB32()
  636.  
  637.  
  638.  
  639. rtgmaster.library/LockRtgScreen                              rtgmaster.library/LockRtgScreen
  640.  
  641.    NAME
  642.         LockRtgScreen -- Locks a RtgScreen (prevents it from being moved
  643.                          in memory)
  644.  
  645.    SYNOPSIS
  646.         address = LockRtgScreen(RtgScreen)
  647.          D0                      A0
  648.  
  649.         APTR LockRtgScreen(ULONG)
  650.  
  651.    FUNCTION
  652.         This function should make sure that the screen is not moved from
  653.         it's current location in memory.  In other words, it will guarantee
  654.         that the address you get back from this function remains valid
  655.         until you call UnlockRtgScreen().
  656.     
  657.         The result from this function should be the address of the buffer
  658.         associated with the screen either in the graphics cards own
  659.         memory or the computers memory.
  660.  
  661.         For multi-buffered screens the return-address must point to buffer
  662.         0 for this RtgScreen.  To get the addresses of the other
  663.         buffers the user will use GetBufAdr().
  664.  
  665.         LockRtgScreen and UnlockRtgScreen functions must nest, which means
  666.         you must call an UnlockRtgScreen for every LockRtgScreen.  The
  667.         field rs_Locks in the RtgScreen structure should be used to keep
  668.         track of the number of times a screen was locked.
  669.  
  670.         Note : On some Graphics Boards this function will take some
  671.         CPU time to happen, so it is advised ONLY to call it *once* at the start
  672.         of your code (And UnlockRtgScreen *once* at the end of your code,
  673.         to be on the sure side...)
  674.  
  675.    INPUTS
  676.         RtgScreen - A handle for a valid screen previously opened by
  677.                     this sublibrary's OpenRtgScreen() function.
  678.  
  679.    RESULTS
  680.         address - The address of the (first) buffer of this screen.
  681.  
  682.    SEE ALSO
  683.         UnlockRtgScreen(), OpenRtgScreen(), GetBufAdr()
  684.  
  685. rtgmaster.library/OpenClient                                 rtgmaster.library/OpenClient
  686.  
  687.    NAME
  688.         OpenClient    -- Open a TCP/IP Client
  689.  
  690.    SYNOPSIS
  691.         Socket = OpenClient(SBase,host,port,mode,protocol)
  692.          D0                  A0    A1   D0   D1   D2
  693.  
  694.         struct RTG_Socket *OpenClient(struct Library *,char *,int,int,int)
  695.  
  696.    FUNCTION
  697.         For TCP, this function opens a "virtual connection" between two applications.
  698.         For UDP it creates a socket that can be used by the application to
  699.         transfer data connectionless to other applications.
  700.         This function is the "Client part" of the connection. The protocol
  701.         being used is TCP/IP.
  702.  
  703.         For more information, look at the docs. There is a chapter about
  704.         "TCP/IP programming for newcomers", that shows you, how to support
  705.         netework gaming for your computer game, even if you never heard of
  706.         TCP/IP before :) Up to now rtgmaster.library only supports the
  707.         "protocol stack" AmiTCP, no AS225 support up to now.  Runs for sure
  708.         with AmiTCP 4.0 demo from Aminet, i do not know about earlier versions.
  709.  
  710.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  711.         yourselves and provide it as parameter. This is needed because of some internal
  712.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  713.         at the Docs for more information.
  714.  
  715.         You do NOT have to use rtgmaster.library's Graphics Board features to
  716.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  717.  
  718.         Actually this function is now inside rtgextra.library.
  719.  
  720.    INPUTS
  721.         SBase    - Result of the call (C Syntax here...)
  722.                    SBase = OpenLibrary("bsdsocket.library",0);
  723.         host     - hostname of the "Server",  to which you want to connect your
  724.                    application (for example "194.55.101.26").
  725.         port     - The port your application uses. For example 4000.
  726.                    Be sure to use a number bigger than 3000, small numbers
  727.                    are often used for different protocols in TCP/IP. For example
  728.                    21 is telnet.
  729.         mode     - The mode of the connection. Up to now only SOCK_STREAM is
  730.                    supported ("virtual connection using a datastream").
  731.                    SOCK_DGRAM probably will give you a UDP connection, but
  732.                    i do not know enough about UDP to make this really working...
  733.                    maybe in a future version...
  734.         protocol - The protocol To be used. Set this to 0 currently.
  735.                    mode SOCK_STREAM and protocol 0 will result in a TCP connection.
  736.  
  737.  
  738.    RESULTS
  739.         Socket   - The "Socket" of the Application. See more in the docs.
  740.  
  741.    SEE ALSO
  742.         OpenServer(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  743.  
  744. rtgmaster.library/OpenRtgScreen                              rtgmaster.library/OpenRtgScreen
  745.  
  746.    NAME
  747.         OpenRtgScreen -- Open a screen
  748.  
  749.    SYNOPSIS
  750.         RtgScreen = OpenRtgScreen(ScreenReq, RtgTags)
  751.          D0                        A0         A1
  752.  
  753.         struct RtgScreen *OpenRtgScreen(struct ScreenReq *, struct TagItem *)
  754.  
  755.  
  756.    FUNCTION
  757.         This function should open the screen which falls within the 
  758.         parameters specified by the user.  If this function can't
  759.         deliver such a screen than it will fail and will return zero.
  760.  
  761.         Note that the Width and Height values you get from
  762.         rtgmaster.library have been checked to see if they are valid
  763.         for this screenmode.  Also note that RtgTags may be zero.
  764.  
  765.    INPUTS
  766.         RtgTags - Pointer to (an array of) TagItem structures,
  767.                   terminated by the value TAG_END (0).
  768.         ScreenReq - ScreenReq structure as returned by RtgScreenModeReq()
  769.                     of rtgmaster.library, see rtg.i for more information
  770.  
  771.         Each TagItem is an optional tagged data structure which
  772.         identifies a parameter to OpenRtgScreen().  The applicable tag ID
  773.         values for TagItem.ti_Tag and their corresponding data can be
  774.         found in the .i/.h file where the Tags for OpenRtgScreen() are
  775.         specified.
  776.  
  777.    RESULTS
  778.         RtgScreen - A handle for the screen you opened.  The user may
  779.                     later use this handle to get information about
  780.                     this screen or perform actions like setting the 
  781.                     palette or double/triple buffering.  You should
  782.                     returns NULL if the screen couldn't be opened.
  783.  
  784.    SEE ALSO
  785.         CloseRtgScreen()
  786.  
  787. rtgmaster.library/OpenServer                               rtgmaster.library/OpenServer
  788.  
  789.    NAME
  790.         OpenServer - Opens a TCP/IP Server
  791.  
  792.    SYNOPSIS
  793.         Socket=OpenServer(SBase,port,mode,protocol)
  794.          D0                A0    D0   D1   D2
  795.  
  796.         struct TCP_Connect *OpenServer(struct Library *,int,int,int)
  797.  
  798.    FUNCTION
  799.         For TCP this function opens a "virtual connection" between two applications.
  800.         For UDP it creates a server that UDP clients can access.
  801.  
  802.         This function is the "Server part" of the connection. The protocol
  803.         being used is TCP/IP. Up to now, as to the "transport protocol", only
  804.         TCP is supported, no UDP (maybe in a future version ???)
  805.         For more information, look at the docs. There is a chapter about
  806.         "TCP/IP programming for newcomers", that shows you, how to support
  807.         netework gaming for your computer game, even if you never heard of
  808.         TCP/IP before :) Up to now rtgmaster.library only supports the
  809.         "protocol stack" AmiTCP, no AS225 support up to now.  Runs for sure
  810.         with AmiTCP 4.0 demo from Aminet, i do not know about earlier versions.
  811.  
  812.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  813.         yourselves and provide it as parameter. This is needed because of some internal
  814.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  815.         at the Docs for more information.
  816.  
  817.         You do NOT have to use rtgmaster.library's Graphics Board features to
  818.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  819.  
  820.         Actually this function is now inside rtgextra.library.
  821.  
  822.    INPUTS
  823.         SBase    - Result of the call (C Syntax here...)
  824.                    SBase = OpenLibrary("bsdsocket.library",0);
  825.         port     - The port your application uses. For example 4000.
  826.                    Be sure to use a number bigger than 3000, small numbers
  827.                    are often used for different protocols in TCP/IP. For example
  828.                    21 is telnet.
  829.         mode     - The mode of the connection. Up to now only SOCK_STREAM is
  830.                    supported ("virtual connection using a datastream").
  831.                    SOCK_DGRAM probably will give you a UDP connection, but
  832.                    i do not know enough about UDP to make this really working...
  833.                    maybe in a future version...
  834.         protocol - The protocol To be used. Set this to 0 currently.
  835.                    mode SOCK_STREAM and protocol 0 will result in a TCP connection.
  836.  
  837.    RESULTS
  838.         Socket   - The "Socket" of the Application. See more in the docs.
  839.  
  840.  SEE ALSO
  841.         OpenClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  842.  
  843. rtgmaster.library/RtgAccept                                rtgmaster.library/RtgAccept
  844.  
  845.    NAME
  846.         RtgAccept - Let the server accept a connection deminded by a Client
  847.  
  848.    SYNOPSIS
  849.         Socket=RtgAccept(SBase,Socket)
  850.          D0               A0    A1
  851.  
  852.         struct RTG_Socket *RtgAccept(struct Library *,struct RTG_Socket *)
  853.  
  854.    FUNCTION
  855.         if you do not use the RunServer function (you do not use it, if you only
  856.         do a point-to-point connection), you have to do this call on Server side
  857.         to wait for the Client to connect. If you use RunSercer, DO NOT USE IT. It
  858.         is only for connecting exactly TWO systems (one being  the server, one the
  859.         client), not for connecting ONE server with SEVERAL clients...
  860.  
  861.         Also do not use it for UDP connection. RtgAccept is only needed for TCP.
  862.         It does not work with UDP.
  863.  
  864.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  865.         yourselves and provide it as parameter. This is needed because of some internal
  866.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  867.         at the Docs for more information.
  868.  
  869.         You do NOT have to use rtgmaster.library's Graphics Board features to
  870.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  871.  
  872.         Actually this function is now inside rtgextra.library.
  873.  
  874.  
  875.    INPUTS
  876.         SBase    - Result of the call (C Syntax here...)
  877.                    SBase = OpenLibrary("bsdsocket.library",0);
  878.         Socket   - the Socket of the Server
  879.  
  880.     RESULTS
  881.         Socket   - The "Socket" of the Client, that connected. See more in the docs.
  882.  
  883.     SEE ALSO
  884.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgRecv(),RtgIoctl(),GetUDPName(),RtgInAdr()
  885.  
  886. rtgmaster.library/RtgAllocSRList                           rtgmaster.library/RtgAllocSRList
  887.  
  888.    NAME
  889.         RtgAllocSRList - Allocates a list of certain ScreenReq Structures
  890.  
  891.    SYNOPSIS
  892.         RtgAllocSRList(tags)
  893.                         A0
  894.  
  895.         struct ScreenReqList *RtgAllocSMList(struct TagItem *)
  896.  
  897.    FUNCTION
  898.         This function provides a list of ScreenReq Structures for all
  899.         Screenmodes that fit for the provided tags. It can be used
  900.         instead of the RtgMaster ScreenMode-Requester.
  901.         The Memory is freed again with FreeRtgScreenReqList().
  902.  
  903.    INPUTS
  904.         tags - tags describing the modes
  905.  
  906.    SEE ALSO
  907.         RtgScreenModeReq(), FreeRtgScreenModeReq(), FreeRtgSRList()
  908.  
  909. rtgmaster.library/RtgBestSR                                rtgmaster.library/RtgBestSR
  910.  
  911.    NAME
  912.         RtgBestSR - calculates the best to be used ScreenReq Structure
  913.  
  914.    SYNOPSIS
  915.         RtgBestSR(tags)
  916.                   A0
  917.  
  918.         struct ScreenReq *RtgBestSR(struct TagItem *)
  919.  
  920.    FUNCTION
  921.         This function looks for the best to be used ScreenMode for the provided tags
  922.         and returns a ScreenReq Structure for it.
  923.  
  924.    INPUTS
  925.         tags - The Tags for the Screenmode
  926.  
  927.    SEE ALSO
  928.         RtgScreenModeReq(), FreeRtgScreenModeReq(), FreeRtgSRList(), AllocRtgSRList()
  929.  
  930. rtgmaster.library/RtgBlit                                  rtgmaster.library/RtgBlit
  931.  
  932.    NAME
  933.         RtgBlit - Performs a Blit without waiting
  934.  
  935.    SYNOPSIS
  936.         RtgBlit(RtgScreen,SrcBuf,DstBuf,SrcX,SrcY,DstX,DstY,Width,Height,Minterm)
  937.                  A0        a1     a2     d0   d1   d2   d3   d4    d5     d6
  938.  
  939.         void RtgBlit(struct RtgScreen *, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG,UBYTE)
  940.  
  941.    FUNCTION
  942.         This function blits the rectangle at (SrxX,SrcY) in the Buffer with the
  943.         NUMBER SrcBuf (0-2) to the position (DstX,DstY) in the Buffer with the
  944.         NUMBER DstBuf (0-2). The Blit has Width Width and Height Height.
  945.  
  946.         For most GFX Boards this function is the fastest way to move
  947.         graphics data.
  948.  
  949.         Note : On some boards (for example EGS Boards) this function might
  950.         wait on the Blitter to be finished as this can't be done in an
  951.         other way with these boards. For these boards WaitRtgBlit simply
  952.         does nothing.
  953.  
  954.         Note : The source and the destination rectangle should NOT OVERLAP !!!
  955.  
  956.         Valid minterms : $30,$50,$60,$80, $C0. NO OTHER MINTERMS ARE VALID.
  957.         OTHER MINTERMS MIGHT WORK WITH SOME SUBLIBRARIES, BUT PROBABLY NOT WITH
  958.         ALL SUBLIBRARIES.
  959.  
  960.         Note: This function MIGHT or MIGHT NOT work with some of the Minterms
  961.         on rtgEGS.library... at least for $C0 it works for all... for the rest...
  962.         i do not see myself as Betatester of half-finished WB-Emulations...
  963.  
  964.         THIS FUNCTION IS IMPLEMENTED IN SUBLIBRARIES STARTING WITH VERSION 1.8
  965.  
  966.    INPUTS
  967.         RtgScreen - The RtgScreen where the Blit should happen
  968.         SrcBuf - The Buffer NUMBER (not address !!!) of the Source Buffer
  969.         DstBuf - The Buffer NUMBER (not address !!!) of the Destination Buffer
  970.         SrcX - The X coordinate of the source Rectangle
  971.         SrcY - The Y coordinate of the source Rectangle
  972.         DstX - The X coordinate of the Destination Rectangle
  973.         DstY - The Y coordinate of the Destination Rectangle
  974.         Width - The Width of the Blit
  975.         Height - The Height of the Blit
  976.         minterm - the minterm of the Blit, defined as usual
  977.  
  978.    SEE ALSO
  979.         OpenRtgScreen(), WaitRtgBlit(), SwitchScreens()
  980.  
  981. rtgmaster.library/RtgBltClear                              rtgmaster.library/BltClear
  982.  
  983.    SYNOPSIS
  984.         RtgBltClear(RtgScreen,BufNum,xpos,ypos,width,height)
  985.                      a0        a1     d0   d1   d2    d3
  986.  
  987.         RtgBltClear(struct RtgScreen *,ULONG,ULONG,ULONG,ULONG,ULONG)
  988.  
  989.    FUNCTION
  990.         This function clears a rectangular area using the GFX Board
  991.         blitter. For people who wonder, why i did not implement that
  992.         the "usual" way, like done in graphics.library : The graphics.library
  993.         function would not be possible under EGS, therefor i did it
  994.         this way. The function usually does not wait for the Blitter,
  995.         use WaitRtgBlit for this (unless under EGS... like explained
  996.         in RtgBlit and WaitRtgBlit...)
  997.  
  998.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  999.  
  1000.    INPUTS
  1001.         RtgScreen - The RtgScreen
  1002.         BufNum - The NUMBER of the concerned Buffer, between 0 and 2 (NOT the buffer address !!!)
  1003.         xpos - the start x position of the rectangle to be cleared
  1004.         ypos - the start y position of the rectangle to be cleared
  1005.         width - the width of the rectangle
  1006.         height - the height of the rectangle
  1007.  
  1008.    SEE ALSO
  1009.         RtgBlit(),WaitRtgBlit()
  1010.  
  1011. rtgmaster.library/RtgCheckVSync                             rtgmaster.library/RtgCheckVSync
  1012.  
  1013.    NAME
  1014.         RtgCheckVSync - Check, if the ray is currently inside Vertical Blank Gap
  1015.  
  1016.    SYNOPSIS
  1017.         RtgCheckVSync(RtgScreen)
  1018.                        A0
  1019.  
  1020.         int RtgCheckVSync(struct RtgScreen *)
  1021.  
  1022.    FUNCTION
  1023.         This function returns 0, if the ray is OUTSIDE the Vertical Blank Gap, 1, if
  1024.         it is INSIDE, and 2, if this is not supported by the GFX Board (in which
  1025.         case a RtgWaitTOF() will be done by this function).
  1026.  
  1027.    INPUTS
  1028.         RtgScreen - The RtgScreen of the GFX Board to be used
  1029.  
  1030.    SEE ALSO
  1031.         RtgWaitTOF()
  1032.  
  1033. rtgmaster.library/RtgClearPointer                           rtgmaster.library/RtgClearPointer
  1034.  
  1035.    NAME
  1036.         RtgClearPointer - resets the pointer to its default image
  1037.  
  1038.    SYNOPSIS
  1039.         RtgClearPointer(RtgScreen)
  1040.                          A0
  1041.  
  1042.         void RtgClearPointer(struct RtgScreen *)
  1043.  
  1044.    FUNCTION
  1045.         This restores the default image of the mousepointer. This is
  1046.         very useful, if you changed it with RtgSetPointer, but sometimes
  1047.         want the default pointer image, too. The pointer is only changed
  1048.         on THIS RtgScreen.
  1049.  
  1050.    INPUTS
  1051.         RtgScreen - The RtgScreen, which pointer should be resetted...
  1052.  
  1053.    NOTES
  1054.        Not implemented yet on rtgPICA.library and rtgEGS.library
  1055.  
  1056.    SEE ALSO
  1057.        RtgSetPointer()
  1058.  
  1059. rtgmaster.library/RtgCloseFont                              rtgmaster.library/RtgCloseFont
  1060.  
  1061.    NAME
  1062.         RtgCloseFont - closes an AmigaFont
  1063.  
  1064.    SYNOPSIS
  1065.         RtgCloseFont(RtgScreen,font)
  1066.                       A0        A1
  1067.  
  1068.         void RtgCloseFont(struct RtgScreen *,void *)
  1069.  
  1070.    FUNCTION
  1071.         This function closes an AmigaFont on
  1072.         a RtgScreen, much the same way, like OpenDiskFont does for
  1073.         Intuition Screens. The font parameter of the call
  1074.         is not for all WB Emulations a TextFont pointer. Don't use
  1075.         CloseFont with rtgmaster.library, use
  1076.         RtgCloseFont, for the best possible compatibility with
  1077.         all Sublibraries !!!
  1078.  
  1079.    INPUTS
  1080.         RtgScreen - an RtgScreen
  1081.         font      - a Font pointer. the structure of it is PRIVATE
  1082.                     to rtgmaster.library (and not the same for all
  1083.                     sublibraries...)
  1084.  
  1085.    NOTES
  1086.         Not yet implemented for rtgPICA.library
  1087.  
  1088.    SEE ALSO
  1089.         RtgOpenFont(),RtgSetFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  1090.  
  1091. rtgmaster.library/RtgConvert                               rtgmaster.library/RtgConvert
  1092.  
  1093.   NAME
  1094.         RtgConvert - convert 24 Bit Formats
  1095.  
  1096.   SYNOPSIS
  1097.         RtgConvert(source,dest,bpr,height,format,cspace)
  1098.                     A0     A1   D0  D1     D2     D3
  1099.  
  1100.         void RtgConvert(UBYTE *,UBYTE *,int,int,int,int)
  1101.  
  1102.   FUNCTION
  1103.         This function converts a (source) Array which has the format 24 Bit RGB
  1104.         (%rrrrrrrr gggggggg bbbbbbbb) to *any* 15-32 Bit Chunky Format. The (dest)
  1105.         Format has to be given in terms of grd, like defined in the grd_... defines
  1106.         in rtgsublibs.h/.i. Also BPR and height of the source buffer have to be
  1107.         given. The function works both of Video RAM and FastRAM. 24 Bit Planar
  1108.         Conversions are not yet supported, but there are plans for HAM/HAM8 c2p
  1109.         for the next version of rtgmaster.
  1110.  
  1111.         Note: The PPC Version will speed up a lot in most cases !!!
  1112.  
  1113.   INPUTS
  1114.         source - the source buffer
  1115.         dest   - the destination buffer
  1116.         bpr    - the source bpr
  1117.         height - the source height
  1118.         format - the destination format
  1119.         cspace - the destination colorspace
  1120.  
  1121.   SEE ALSO
  1122.  
  1123. rtgmaster.library/RtgInAdr                                 rtgmaster.library/RtgInAdr
  1124.  
  1125.    NAME
  1126.         RtgInAdr - Find out the IP Address of a Receiver/Sender
  1127.  
  1128.    SYNOPSIS
  1129.         ip = RtgInAdr(SBase,si)
  1130.         D0             A0   A1
  1131.  
  1132.         char *RtgInAdr(struct Library *,struct sockaddr_in *)
  1133.  
  1134.    FUNCTION
  1135.         This function finds out the IP Address of a Receiver/Sender.
  1136.         You get back the sockaddr_in structure of a receiver/sender by
  1137.         RtgRecv/RtgSend or by using GetUDPName. This function ONLY
  1138.         works for UDP, not for TCP !!! It is used to differentiate
  1139.         Clients running on different machines from each other, if
  1140.         one does a Multiple Client "connection" (should not be called
  1141.         like that, as UDP is connectionless, but do you know a better
  1142.         term ?), without using RunServer...
  1143.  
  1144.         Of course this function can't differentiate multiple Clients
  1145.         running on the same machine...
  1146.  
  1147.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1148.         yourselves and provide it as parameter. This is needed because of some internal
  1149.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1150.         at the Docs for more information.
  1151.  
  1152.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1153.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1154.  
  1155.         Actually this function is now inside rtgextra.library.
  1156.  
  1157.    INPUTS
  1158.           SBase    - Result of the call (C Syntax here...)
  1159.                      SBase = OpenLibrary("bsdsocket.library",0);
  1160.           si       - Special structure returned by above mentioned calls
  1161.  
  1162.    RESULTS
  1163.           ip       - IP Address as string (for example "194.55.101.26")
  1164.  
  1165.    SEE ALSO
  1166.         OpenClient(),OpenServer(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),GetUDPName()
  1167.  
  1168. rtgmaster.library/RtgInitBob                               rtgmaster.library/RtgInitBob
  1169.  
  1170.    NAME
  1171.         RtgInitBob - Initializes a RtgBob
  1172.  
  1173.    SYNOPSIS
  1174.         RtgInitBob(RtgScreen, RtgBob,BackAdr,BufferAdr,xpos,ypos,display)
  1175.                     A0         A1      A2     A3       D0    D1   D2
  1176.  
  1177.         RtgInitBob(struct RtgBob *)
  1178.  
  1179.    FUNCTION
  1180.         Initializes a RtgBob for display. This has to be done before using a
  1181.         RtgBob. If the Bob was already initted, the Bob is simply moved
  1182.         to the position given (but you can init and display it in the
  1183.         same function call, also). BackAdr is the BackBuffer to be used
  1184.         with the Bob, this BackBuffer CANNOT be used for Doublebuffering
  1185.         or other purposes (but you can use a Fastram-Buffer as Backbuffer,
  1186.         also). You only have to supply the BackBuffer the first time you
  1187.         use the Bob.
  1188.  
  1189.         Rtgmaster Bobs are limited to 32x32 resolutions.
  1190.  
  1191.         Not yet implemented.
  1192.  
  1193.    INPUTS
  1194.         RtgBob    - The RtgBob structure
  1195.         BackAdr   - The VideoRAM or FastRAM Buffer for Bob Refresh
  1196.         BufferAdr - The Video RAM Buffer, where the Bob should be displayed
  1197.         xpos      - The xposition the Bob should be placed
  1198.         ypos      - The yposition the Bob should be placed
  1199.         display   - If this is 1, the Bob will be switched on, if 0, it will
  1200.                     be disabled.
  1201.  
  1202.    SEE ALSO
  1203.  
  1204. rtgmaster.library/RtgIoctl                                 rtgmaster.library/RtgIoctl
  1205.  
  1206.    NAME
  1207.         RtgIoctl - Set a Socket to "Blocking" or to "Non-Blocking" mode
  1208.  
  1209.    SYNOPSIS
  1210.         result = RtgIoctl(SBase,Socket,arg)
  1211.          D0                A0    A1     A2
  1212.  
  1213.         int RtgIoctl(struct Library *,struct RTG_Socket *,long *)
  1214.  
  1215.    FUNCTION
  1216.         This function determins, if RtgRecv and RtgSend will WAIT will the data
  1217.         was transmitted, or if they fail, if the data currently could not be
  1218.         transmitted. If arg POINTS to the VALUE 1, we have "non-blocking" (it does
  1219.         not wait), if it POINTS to 0, we have "blocking" (it waits). Default (if
  1220.         you do not call RtgIoctl at all) is "blocking".
  1221.  
  1222.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1223.         yourselves and provide it as parameter. This is needed because of some internal
  1224.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1225.         at the Docs for more information.
  1226.  
  1227.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1228.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1229.  
  1230.         RtgIoctl is a VERY CPU TIME INTENSIVE FUNCTION !!!
  1231.         Only call it during the INITIALIZATION of the network !!!
  1232.  
  1233.         My suggestion : Run the server in "blocking" mode, the Clients in
  1234.         "nonblocking" mode... seems to be the fastest...
  1235.  
  1236.         Actually this function is now inside rtgextra.library.
  1237.  
  1238.    INPUTS
  1239.         SBase    - Result of the call (C Syntax here...)
  1240.                    SBase = OpenLibrary("bsdsocket.library",0);
  1241.         Socket   - The Socket of the application, which socket is to be modified
  1242.         arg      - "Non-Blocking" or "Blocking" (a pointer)
  1243.  
  1244.    RESULTS
  1245.         result   - 0 on success, -1 on fail (should not fail,normally...)
  1246.  
  1247.    SEE ALSO
  1248.         OpenClient(),OpenServer(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),GetUDPName(),RtgInAdr()
  1249.  
  1250. rtgmaster.library/RtgOpenFont                              rtgmaster.library/RtgOpenFont
  1251.  
  1252.    NAME
  1253.         RtgOpenFont - opens an AmigaFont
  1254.  
  1255.    SYNOPSIS
  1256.         font = RtgOpenFont(RtgScreen,ta)
  1257.          D0                 A0       A1
  1258.  
  1259.         void * RtgOpenFont(struct RtgScreen *,struct TextAttr *)
  1260.  
  1261.    FUNCTION
  1262.         This function loads an AmigaFont to memory, for the usage on
  1263.         a RtgScreen, much the same way, like OpenDiskFont does for
  1264.         Intuition Screens. ta is a normal TextAttr pointer, like
  1265.         for OpenDiskFont for diskfont.library, but the RESULT
  1266.         is not for all WB Emulations a TextFont pointer. Don't use
  1267.         OpenDiskFont or OpenFont with rtgmaster.library, use
  1268.         RtgOpenFont, for the best possible compatibility with
  1269.         all Sublibraries !!!
  1270.  
  1271.    INPUTS
  1272.         RtgScreen - an RtgScreen
  1273.         ta        - a TextAttr structure, like defined in graphics/text.i (or .h)
  1274.  
  1275.    RESULTS
  1276.         font      - A pointer to a font pointer. It's internal structure is
  1277.                     PRIVATE to rtgmaster.library, and NOT THE SAME for all
  1278.                     sublibraries
  1279.  
  1280.    NOTES
  1281.         Not yet implemented for rtgPICA.library
  1282.  
  1283.    SEE ALSO
  1284.         RtgCloseFont(),RtgSetFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  1285.  
  1286. rtgmaster.library/RtgRecv                                  rtgmaster.library/RtgRecv
  1287.  
  1288.    NAME
  1289.         RtgRecv - The Socket of this application receives data from a connected socket
  1290.  
  1291.    SYNOPSIS
  1292.         length = RtgRecv(SBase,Socket,message,sender,len)
  1293.          D0               A0    A1     A2      A3     D0
  1294.  
  1295.         int RtgRecv(struct Library *,struct RTG_Socket *,struct char *,struct sockaddr_in *,int)
  1296.  
  1297.    FUNCTION
  1298.         This function is no longer compatible to rtgmaster.library V6 and below !!!
  1299.  
  1300.         This function gets data to the application that is sent to its socket by a socket
  1301.         that is connected to the socket of the Application (it is not that difficult to
  1302.         understand like it sounds... read the docs :) )
  1303.  
  1304.         If the "virtual connection" (or the "connectionless connection" or what this is called
  1305.         for UDP... :) ) is "blocking", it WAITS, if there is no message available
  1306.         on the socket, till one is available. If it is "non-blocking", it returns -1, if no
  1307.         message is available (see RtgIoctl for more details about "blocking" and "Non-Blocking".
  1308.         The default is "Blocking", BTW...)
  1309.  
  1310.         Sender is a special structure that you can use to find out from what IP Address
  1311.         the message was sent. You can convert it to an IP Address using RtgInAdr. This
  1312.         only works with UDP (with TCP, you differentiate Clients from each other with the
  1313.         socket number...). Appearently, you CAN'T differentiate Clients that run on the
  1314.         same machine !!! Sender is NOT allocated by the function, you have to provide
  1315.         the structure...
  1316.  
  1317.         For TCP you simple provide a 0 for Sender. It will be ignored.
  1318.  
  1319.         You can use this feature to do multiple connection without using RunServer (that
  1320.         does not support UDP up to now anyways...).
  1321.  
  1322.         NOTE: For *TCP* you provide the Socket of the Application which you want to
  1323.         contact. For *UDP* you provide your OWN'S Socket. Important difference !!!
  1324.  
  1325.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1326.         yourselves and provide it as parameter. This is needed because of some internal
  1327.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1328.         at the Docs for more information.
  1329.  
  1330.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1331.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1332.  
  1333.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1334.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1335.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1336.         should NEVER be bigger than the actual message, or you might get a lot
  1337.         of strange results !!!
  1338.  
  1339.         Actually this function is now inside rtgextra.library.
  1340.  
  1341.    INPUTS
  1342.         SBase    - Result of the call (C Syntax here...)
  1343.                    SBase = OpenLibrary("bsdsocket.library",0);
  1344.         Socket   - The Socket of THIS application
  1345.         message  - The buffer, to which supplied messages will be put
  1346.         Sender   - The Function will fill in data about the Sender to this structure.
  1347.         len      - The length of the message to wait for
  1348.  
  1349.    RESULTS
  1350.         length   - The length of the message received. If it is smaller
  1351.                    than the message, you waited for, do a RtgRecv once more...
  1352.                    NOTE: If a message was received that is too long to fit to
  1353.                    the buffer, some Bytes might be discarded. So you should
  1354.                    not send more Bytes than you want to receive... use a standard
  1355.                    Package Size at best...
  1356.     SEE ALSO
  1357.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgSend(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1358.  
  1359. rtgmaster.library/RtgScreenAtFront                         rtgmaster.library/RtgScreenAtFront
  1360.  
  1361.    NAME
  1362.         RtgScreenAtFront - determines if a RtgScreen is at front
  1363.  
  1364.    SYNOPSIS
  1365.         boolean = RtgScreenAtFront(RtgScreen)
  1366.                                     A0
  1367.  
  1368.         RtgScreenAtFront(struct RtgScreen *)
  1369.  
  1370.    FUNCTION
  1371.         This function should determine if this RtgScreen is currently at
  1372.         front.  It should return TRUE (0xfffffff) if the screen is in front
  1373.         of all other screens, and FALSE (0) if the screen is behind (partially
  1374.         or completely) an other screen.
  1375.  
  1376.         Note that this function will not be heavily reliable, since the user
  1377.         might switch screens at any time.
  1378.  
  1379.    INPUTS
  1380.         RtgScreen - A handle for a valid screen previously opened by
  1381.                     this sublibrary's OpenRtgScreen() function.
  1382.  
  1383.    RESULTS
  1384.         boolean - TRUE if screen is at front, FALSE otherwise.
  1385.  
  1386.    SEE ALSO
  1387.         OpenRtgScreen()
  1388.  
  1389. rtgmaster.library/RtgScreenToFront                         rtgmaster.library/RtgScreenToFront
  1390.  
  1391.    NAME
  1392.         RtgScreenToFront - puts a RtgScreen to the front
  1393.  
  1394.    SYNOPSIS
  1395.         RtgScreenToFront(RtgScreen)
  1396.                           A0
  1397.  
  1398.         void RtgScreenToFront(struct RtgScreen *)
  1399.  
  1400.    FUNCTION
  1401.         This function can serve two purposes. First you can handle with it
  1402.         several RtgScreens at the same time, second you can with it hinder
  1403.         - at the cost of some performance - that the Workbench Screen is
  1404.         garbaged. I would do this second usage optionally only, though.
  1405.         Note: Picasso96 already handles the stuff that the WB screen is
  1406.         not garbaged, internally, the second usage would be only needed
  1407.         for CyberGraphX.
  1408.  
  1409.    INPUTS
  1410.         RtgScreen - A handle for a valid screen previously opened by
  1411.                     this sublibrary's OpenRtgScreen() function.
  1412.  
  1413.    RESULTS
  1414.         none
  1415.  
  1416.    SEE ALSO
  1417.         OpenRtgScreen()
  1418.  
  1419. rtgmaster.library/RtgScreenModeReq                        rtgmaster.library/RtgScreenModeReq
  1420.  
  1421.    NAME
  1422.         RtgScreenModeReq -- Opens a ScreenMode requester
  1423.  
  1424.    SYNOPSIS
  1425.         ScreenReq = RtgScreenModeReq(ScreenModeTags)
  1426.          D0                           A0
  1427.  
  1428.         struct ScreenReq *RtgScreenModeReq(struct TagItem *)
  1429.  
  1430.    FUNCTION
  1431.         Opens a ScreenMode requester which displays all available
  1432.         ScreenModes to the user, depending on the Tags which are passed
  1433.         to this function.  The functions returns a pointer to a
  1434.         ScreenReq structure or NULL for failure or if the user
  1435.         cancelled the requester.
  1436.  
  1437.         The ScreenReq holds various information which the user selected,
  1438.         like width, height, screenmode and depth.
  1439.  
  1440.         THIS FUNCTION IS ONLY IN THE MASTER-LIBRARY. It handles the Screenmodes
  1441.         for ALL sublibraries.
  1442.  
  1443.         Note: The Screenmode-Requester provided with an early Beta of the
  1444.         rtgmaster.library was VERY buggy. It got completely replaced by
  1445.         a new one for this version of the library.
  1446.  
  1447.    INPUTS
  1448.         ScreenModeTags - Pointer to (an array of) TagItem structures,
  1449.                          terminated by the value TAG_END (0).
  1450.  
  1451.         The description for the various tags can be found in the .i/.h
  1452.         file (smr_Tags). NOTE: The Tags changed a lot since the early
  1453.         Beta release of the library.
  1454.  
  1455.    RESULTS
  1456.         ScreenReq - A pointer to a ScreenReq structure or NULL for
  1457.                     failure
  1458.  
  1459.    SEE ALSO
  1460.         OpenRtgScreen(),FreeRtgScreenModeReq()
  1461.  
  1462. rtgmaster.library/RtgSend                                  rtgmaster.library/RtgSend
  1463.  
  1464.    NAME
  1465.         RtgSend - The Socket of this application sends data to a connected socket
  1466.  
  1467.    SYNOPSIS
  1468.         length = RtgSend(SBase,Socket,message,Receiver,len)
  1469.          D0               A0    A1     A2      A3       D0
  1470.  
  1471.         int RtgSend(struct Library *,struct RTG_Socket *,struct char *,struct sockaddr_in *,int)
  1472.  
  1473.    FUNCTION
  1474.         This function is no longer compatible to rtgmaster.library V6 and below !!!
  1475.  
  1476.         This function puts data from the application to the socket of an application
  1477.         that is connected to the socket of the Application (it is not that difficult to
  1478.         understand like it sounds... read the docs :) )
  1479.  
  1480.         If the "virtual connection" (well, this term does not fit for UDP, as it is
  1481.         connectionless, but i do not know how to call it else... :) ) is "blocking", it WAITS, if there is no message available
  1482.         on the socket, till one is available. If it is "non-blocking", it returns -1, if no
  1483.         message is available (see RtgIoctl for more details about "blocking" and "Non-Blocking".
  1484.         The default is "Blocking", BTW...)
  1485.  
  1486.         Receiver is a special structure that you can use to tell the receiver your IP Address.
  1487.         You get your IP Address with GetUDPName (works only for UDP... for TCP this returns
  1488.         0...). For TCP you provide simply 0 for Receiver, it will be ignored.
  1489.         You can convert it to an IP Address using RtgInAdr. This
  1490.         only works with UDP (with TCP, you differentiate Clients from each other with the
  1491.         socket number...). Appearently, you CAN'T differentiate Clients that run on the
  1492.         same machine !!!
  1493.  
  1494.         You can use this feature to do multiple connection without using RunServer (that
  1495.         does not support UDP up to now anyways...).
  1496.  
  1497.         NOTE: For *TCP* you provide the Socket of the Application which you want to
  1498.         contact. For *UDP* you provide your OWN'S Socket. Important difference !!!
  1499.  
  1500.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1501.         yourselves and provide it as parameter. This is needed because of some internal
  1502.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1503.         at the Docs for more information.
  1504.  
  1505.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1506.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1507.  
  1508.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1509.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1510.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1511.         should NEVER be bigger than the actual message, or you might get a lot
  1512.         of strange results !!!
  1513.  
  1514.         Actually this function is now inside rtgextra.library.
  1515.  
  1516.    INPUTS
  1517.         SBase    - Result of the call (C Syntax here...)
  1518.                    SBase = OpenLibrary("bsdsocket.library",0);
  1519.         Socket   - The Socket of THIS application
  1520.         message  - The message to be sent (an ASCII string, actually...)
  1521.         Receiver - The data you got from GetUDPName, tells the receiver your IP address...
  1522.         len      - The length of the string to send ...
  1523.  
  1524.    RESULTS
  1525.         length   - The length of the message sent. If it is smaller
  1526.                    than the message, you sent, do a RtgSend once more...
  1527.                    Probably the socket you sent to was quite busy with other
  1528.                    messages currently...
  1529.  
  1530.                    NOTE: If the send fails at all, maybe your message was too
  1531.                    long for TCP/IP ? (As to the allowed package sizes, 1 KB works
  1532.                    for sure... i do not know exactly how much more is possible...)
  1533.  
  1534.     SEE ALSO
  1535.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgRecv(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1536.  
  1537. rtgmaster.library/RtgSetFont                              rtgmaster.library/RtgSetFont
  1538.  
  1539.    NAME
  1540.         RtgSetFont - sets an AmigaFont to an RtgScreen
  1541.  
  1542.    SYNOPSIS
  1543.         RtgSetFont(RtgScreen,font)
  1544.                     A0        A1
  1545.  
  1546.         void RtgSetFont(struct RtgScreen *,void *)
  1547.  
  1548.    FUNCTION
  1549.         This function sets an AmigaFont (that was opened using
  1550.         RtgOpenFont tomemory before) to an RtgScreen. Following
  1551.         RtgText() calls will use this font, now.
  1552.  
  1553.    INPUTS
  1554.         RtgScreen - an RtgScreen
  1555.         font      - a Font pointer. the structure of it is PRIVATE
  1556.                     to rtgmaster.library (and not the same for all
  1557.                     sublibraries...)
  1558.  
  1559.    NOTES
  1560.         Not yet implemented for rtgPICA.library
  1561.  
  1562.    SEE ALSO
  1563.         RtgOpenFont(),RtgCloseFont(),RtgSetTextMode(),RtgText(),RtgSetTextModeRGB
  1564.  
  1565. rtgmaster.library/RtgSetPointer                           rtgmaster.library/RtgSetPointer
  1566.  
  1567.    NAME
  1568.         RtgSetPointer - sets the pointer to a new image
  1569.  
  1570.    SYNOPSIS
  1571.         RtgSetPointer(RtgScreen,pointer,Width,Height,OffsetX,OffsetY)
  1572.                          A0      A1      D0    D1     D2      D3
  1573.  
  1574.         void RtgSetPointer(struct RtgScreen *,UWORD *,WORD,WORD,WORD,WORD)
  1575.  
  1576.    FUNCTION
  1577.         This function sets the mousepointer to a new image for this RtgScreen.
  1578.         The structure pointer is exactly the same like taken from intuition.library
  1579.         command SetPointer (the data definition of a Simple Sprite). Different
  1580.         from this only is that the image HAS TO BE 16x18 pixels size. If you
  1581.         want a smaller pointer, modify the Width/Height values and set that
  1582.         pixels that you do not need to 0. But the SIZE of the structure has
  1583.         to be 16x18 pixels (72 Bytes). An example :
  1584.  
  1585.         UWORD Hoehe[2]
  1586.         {
  1587.             0x...,0x... // first line
  1588.             ...
  1589.             0x...,0x... // 18th line
  1590.         }
  1591.  
  1592.         Look at graphics.library SimpleSprite documentation for more information
  1593.         (01,10,11 are the three pointer colors,00 is transperent, each of
  1594.         the two words of a line determines ONE BIT of the 2-Bit mousepointer).
  1595.  
  1596.    INPUTS
  1597.         RtgScreen - The RtgScreen, which pointer should be resetted...
  1598.         pointer   - pointer image, see above
  1599.         Width     - Actual Width of the pointer
  1600.         Height    - Actual Height of the pointer
  1601.         OffsetX   - Display Offset for the pointer, from the mouseposition
  1602.         OffsetY   - Display Offset for the pointer, from the mouseposition
  1603.  
  1604.    NOTES
  1605.        Not implemented yet on rtgPICA.library and rtgEGS.library
  1606.  
  1607.        Do NOT specifically demand Chipram for the pointer array.
  1608.        Else your program won't run on the DraCo. rtgmaster.library will
  1609.        handle this itself, that the pointer-image will end in
  1610.        Chipram for ECS/AGA, in ANYTHING AVAILABLE on GFX Board system.
  1611.        So simply allocate RAM for the pointer image, without simply
  1612.        demanding Chipram or Fastram (as DraCo needs FastRam, and
  1613.        ECS/AGA need Chipram here... but well... rtgmaster.library
  1614.        takes care of this :) )
  1615.  
  1616.    SEE ALSO
  1617.        RtgClearPointer()
  1618.  
  1619. rtgmaster.library/RtgSetTextMode                              rtgmaster.library/RtgSetTextMode
  1620.  
  1621.    NAME
  1622.         RtgSetTextMode - sets text color and drawing mode
  1623.  
  1624.    SYNOPSIS
  1625.         RtgSetTextMode(RtgScreen,fgcolor,bgcolor,drmode)
  1626.                         A0        D0      D1      D2
  1627.  
  1628.         void RtgSetTextMode(struct RtgScreen *,UBYTE,UBYTE,UBYTE)
  1629.  
  1630.    FUNCTION
  1631.         Sets the foreground color, the background color and the drawing
  1632.         mode for Text on this RtgScreen.  drmodes are defined as usual
  1633.         in graphics/rastport.i (or .h) : JAM1, JAM2, COMPLEMENT.
  1634.         INVERSVID is not valid...
  1635.  
  1636.         This function should only be used on Displays with depth <=8.
  1637.  
  1638.    INPUTS
  1639.         RtgScreen - an RtgScreen
  1640.         fgcolor   - Foreground color
  1641.         bgcolor   - Background color
  1642.         drwmode   - Drawing mode, defined in graphics/rastport.i (or .h)
  1643.  
  1644.    NOTES
  1645.         Not yet implemented for rtgPICA.library
  1646.  
  1647.    SEE ALSO
  1648.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgText(),RtgSetTextModeRGB()
  1649.  
  1650.  
  1651. rtgmaster.library/RtgSetTextModeRGB                              rtgmaster.library/RtgSetTextModeRGB
  1652.  
  1653.    NAME
  1654.         RtgSetTextModeRGB - sets text color and drawing mode for depths >8
  1655.  
  1656.    SYNOPSIS
  1657.         RtgSetTextModeRGB(RtgScreen,fgcolor,bgcolor,drmode)
  1658.                         A0        D0      D1      D2
  1659.  
  1660.         void RtgSetTextModeRGB(struct RtgScreen *,ULONG,ULONG,UBYTE)
  1661.  
  1662.    FUNCTION
  1663.         Sets the foreground color, the background color and the drawing
  1664.         mode for Text on this RtgScreen.  drmodes are defined as usual
  1665.         in graphics/rastport.i (or .h) : JAM1, JAM2, COMPLEMENT.
  1666.         INVERSVID is not valid...
  1667.  
  1668.         Should only be used on Displays with depth >8.
  1669.  
  1670.    NOTES
  1671.         Due to a bug in CyberGraphX, this function does not work
  1672.         very well with rtgCGX.library (strange colors...). Not yet
  1673.         implemented in rtgPICA.library.
  1674.  
  1675.    INPUTS
  1676.         RtgScreen - an RtgScreen
  1677.         fgcolor   - Foreground color
  1678.         bgcolor   - Background color
  1679.         drwmode   - Drawing mode, defined in graphics/rastport.i (or .h)
  1680.  
  1681.  
  1682.    SEE ALSO
  1683.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgText(),RtgSetTextMode()
  1684.  
  1685.  
  1686. rtgmaster.library/RtgText                              rtgmaster.library/RtgText
  1687.  
  1688.    NAME
  1689.         RtgText - displays Text on an RtgScreen
  1690.  
  1691.    SYNOPSIS
  1692.         RtgText(RtgScreen,buffer,string,length,xpos,ypos)
  1693.                  A0        A1     A2     D0     D1   D2
  1694.  
  1695.         void RtgText(struct RtgScreen *,void *,char *,WORD,SHORT,SHORT)
  1696.  
  1697.    FUNCTION
  1698.         Displays the string "string" with the chosen font parameters (see
  1699.         RtgSetFont(), RtgSetTextMode(), RtgSetTextModeRGB() ) at position
  1700.         xpos,ypos much the same way like Text() of graphics.library does.
  1701.  
  1702.    INPUTS
  1703.         RtgScreen - an RtgScreen
  1704.         buffer    - The buffer address of the buffer where to display the text
  1705.         string    - pointer to a string
  1706.         length    - length of the string in characters
  1707.         xpos      - the x-pos
  1708.         ypos      - the y-pos
  1709.  
  1710.    NOTES
  1711.         Not yet implemented for rtgPICA.library.
  1712.  
  1713.    SEE ALSO
  1714.         RtgOpenFont(),RtgSetFont(),RtgCloseFont(),RtgCloseFont(),RtgSetTextModeRGB(),RtgSetTextMode()
  1715.  
  1716.  
  1717.  
  1718. rtgmaster.library/RtgWaitTOF                                  rtgmaster.library/RtgWaitTOF
  1719.  
  1720.    NAME
  1721.         RtgWaitTOF - Wait for the top of the next video frame.
  1722.  
  1723.    SYNOPSIS
  1724.         WaitTOF(RtgScreen)
  1725.                  A0
  1726.  
  1727.         WaitTOF(struct RtgScreen *)
  1728.  
  1729.    FUNCTION
  1730.         Wait  for vertical blank to occur and all vertical blank
  1731.         interrupt routines to complete before returning to caller.
  1732.  
  1733.         Does not do anything at all with some sublibraries... (CyberGraphX does not
  1734.         support TOF-Waiting up to now...)
  1735.  
  1736.    INPUTS
  1737.         The Screen Handle of the GFX Board Screen (only in FACT needed for rtgEGS.library,
  1738.         and probably nothing much is done about it anyway... but be nice... give this
  1739.         parameter... to stay compatible :) )
  1740.  
  1741.    RESULTS
  1742.         Places this task on the TOF wait queue. When the vertical blank
  1743.         interrupt comes around, the interrupt service routine will fire off
  1744.         signals to all the tasks doing WaitTOF. The highest priority task
  1745.         ready will get to run then.
  1746.  
  1747.    SEE ALSO
  1748.        graphics.library/WaitTOF()
  1749.  
  1750. rtgmaster.library/RunServer                                      rtgmaster.library/RunServer
  1751.  
  1752.    NAME
  1753.         RunServer -- Handle all the messaging for a server and several clients
  1754.  
  1755.    SYNOPSIS
  1756.         New_Socket = RunServer(SBase,Socket,in_buffer,out_buffer,maxplayers)
  1757.          D0                     A0    A1     A2        A3         D0
  1758.  
  1759.         struct RTG_Socket *RunServer(struct Library *,struct RTG_Socket *,struct RTG_Buff *,struct RTG_Buff *,int)
  1760.  
  1761.    FUNCTION
  1762.         You will have to run this fine
  1763.         function in a loop. Every time it returns, it gives you the Socket of a new connected
  1764.         client or 0, if no new Client connected. Also, in  in_buffer, you will have all new
  1765.         messages sent from  already connected Clients to the server, and all messages you filled
  1766.         in in out_buffer before calling this function, will be sent to the Clients.
  1767.         If nothing happened, this function returns at once, with consuming nearly no CPU time.
  1768.  
  1769.         You SHOULD initialize the in_buffer.num values with -1 EACH TIME, before
  1770.         RunServer is run, and the out_buffer.num values once before the FIRST TIME
  1771.         RunServer is called !!!
  1772.  
  1773.         NOTE: If you (later...) use RunServer, the Server can't handle a Player. You need
  1774.         ONE CLIENT PER PLAYER AND AN ADDITIONAL SERVER WITHOUT A PLAYER. The Server can run
  1775.         on a system, where a Client is also running, though (should be the fastest system in
  1776.         the connection, probably, as it will have to do all that messaging to the Client ...)
  1777.  
  1778.         NOTE: It might appear strange to you, that you have to open bsdsocket.library
  1779.         yourselves and provide it as parameter. This is needed because of some internal
  1780.         problems of AmiTCP, that make it IMPOSSIBLE opening it inside a library. Look
  1781.         at the Docs for more information.
  1782.  
  1783.         You do NOT have to use rtgmaster.library's Graphics Board features to
  1784.         use rtgmaster.library's TCP/IP features, if you do not WANT to...
  1785.  
  1786.         NOTE: It is NOT possible to give Socket->s (the Socket Number) of a Client
  1787.         to the Server using RtgRecv or RunServer !!! You will have to examine
  1788.         inbuffer->num[x] to find out which Socket was the Sender !!! Also len
  1789.         should NEVER be bigger than the actual message, or you might get a lot
  1790.         of strange results !!!
  1791.  
  1792.         Actually this function is now inside rtgextra.library.
  1793.  
  1794.  
  1795.    INPUTS
  1796.         SBase      - Result of the call (C Syntax here...)
  1797.                      SBase = OpenLibrary("bsdsocket.library",0);
  1798.         Socket     - The Socket of THIS application (the Server...)
  1799.         in_buffer  - messages that arrived during the call of RunServer
  1800.         out_buffer - messages that Run_Server should deliver
  1801.         maxplayers - The Maximum of Clients allowed (CAN'T BE BIGGER THAN 12 !!!)
  1802.  
  1803.    RESULTS
  1804.         New_Socket - The Socket of a newly connected Client. Save it somewhere...
  1805.  
  1806.    SEE ALSO
  1807.         OpenClient(),CloseClient(),CloseClient(),CloseServer(),RunServer(),RtgRecv(),RtgSend(),RtgAccept(),RtgIoctl(),GetUDPName(),RtgInAdr()
  1808.  
  1809. rtgmaster.library/SwitchScreens                              rtgmaster.library/SwitchScreens
  1810.  
  1811.    NAME
  1812.         SwitchScreens -- Perform doublebuffering
  1813.  
  1814.    SYNOPSIS
  1815.         SwitchScreens(RtgScreen, Buffer)
  1816.                        A0         D0
  1817.  
  1818.         SwitchScreens(ULONG, ULONG)
  1819.  
  1820.    FUNCTION
  1821.         RtgScreen passed in A0 is a handle of a screen previously opened
  1822.         by OpenRtgScreen().
  1823.  
  1824.         This functions is used to specify the buffer which should
  1825.         be displayed starting from the next Vertical Blank.  The buffer
  1826.         supplied is a simple number (0 = first buffer, 1 = 2nd buffer
  1827.         etcetera).
  1828.  
  1829.         If the same buffer is being specified as is being displayed then
  1830.         this function should do nothing.
  1831.  
  1832.         This function will never be called from interupts.
  1833.  
  1834.    INPUTS
  1835.         RtgScreen - A handle for a valid screen previously opened by
  1836.                     this sublibrary's OpenRtgScreen() function.
  1837.         Buffer - The buffer number the user wishes to display
  1838.  
  1839.    SEE ALSO
  1840.         OpenRtgScreen(),WaitRtgSwitch()
  1841.  
  1842.  
  1843.  
  1844. rtgmaster.library/UnlockRtgScreen                          rtgmaster.library/UnlockRtgScreen
  1845.  
  1846.    NAME
  1847.         UnlockRtgScreen -- Unlocks a RtgScreen
  1848.  
  1849.    SYNOPSIS
  1850.         UnlockRtgScreen(RtgScreen)
  1851.                          A0
  1852.  
  1853.         UnlockRtgScreen(ULONG)
  1854.  
  1855.    FUNCTION
  1856.         Unlocks a previously locked RtgScreen.  If this screen hasn't
  1857.         been locked before this function will do nothing.
  1858.  
  1859.         LockRtgScreen() and UnlockRtgScreen() functions nest, which means
  1860.         the user must call an UnlockRtgScreen() for every LockRtgScreen().
  1861.         If not the user will end up with a permenantly locked screen.
  1862.  
  1863.    INPUTS
  1864.         RtgScreen - A handle for a valid screen previously opened by
  1865.                     this sublibrary's OpenRtgScreen() function.
  1866.  
  1867.    SEE ALSO
  1868.         LockRtgScreen()
  1869.  
  1870. rtgmaster.library/WaitRtgBlit                                 rtgmaster.library/WaitRtgBlit
  1871.  
  1872.    NAME
  1873.         WaitRtgBlit - Waits on the Blitter to be finished
  1874.  
  1875.    SYNOPSIS
  1876.         WaitRtgBlit(RtgScreen)
  1877.                     A0
  1878.  
  1879.         WaitRtgBlit(struct RtgScreen *)
  1880.  
  1881.    FUNCTION
  1882.         Waits for the GFX Board Blitter to be finished. For those who wonder,
  1883.         why RtgScreen has to be given as parameter... it probably won't be used...
  1884.         just to be on the sure side :)
  1885.  
  1886.         Does not do anything at all with some sublibraries. Some of them ALWAYS wait...
  1887.  
  1888.    INPUTS
  1889.         RtgScreen - The RtgScreen structure
  1890.  
  1891.    SEE ALSO
  1892.         OpenRtgScreen(), RtgBlit()
  1893.  
  1894. rtgmaster.library/WaitRtgSwitch                               rtgmaster.library/WaitRtgSwitch
  1895.  
  1896.    NAME
  1897.         WaitRtgSwitch - Waits on Doublebuffering having happened
  1898.  
  1899.    SYNOPSIS
  1900.         WaitRtgSwitch(RtgScreen)
  1901.                     A0
  1902.  
  1903.         WaitRtgSwitch(struct RtgScreen *)
  1904.  
  1905.    FUNCTION
  1906.         As SwitchScreens does not wait till the Doublebuffering has happened,
  1907.         but returns AT ONCE, it might be that the program wants to access the
  1908.         video memory BEFORE the change has happened. In this case you can use
  1909.         WaitRtgSwitch to be sure the change really happened. If you do not
  1910.         want to wait, simply do not use this call :)
  1911.  
  1912.         Does not do much for some sublibraries. Some always wait...
  1913.  
  1914.    INPUTS
  1915.         The Screenhandle of the Screen, where the Wait should happen...
  1916.  
  1917.    SEE ALSO
  1918.         SwitchScreens()
  1919.  
  1920.  
  1921.  
  1922.  
  1923. rtgmaster.library/WriteRtgPixel                               rtgmaster.library/WriteRtgPixel
  1924.  
  1925.    NAME
  1926.         WriteRtgPixel - plots a single pixel to a RtgScreen
  1927.  
  1928.    SYNOPSIS
  1929.         WriteRtgPixel(RtgScreen, BufferAdr, XPos, YPos, Color)
  1930.                        A0         A1         D0    D1    D2
  1931.  
  1932.         WriteRtgPixel(struct RtgScreen *, APTR, ULONG, ULONG, UBYTE)
  1933.  
  1934.    FUNCTION
  1935.         Draws a single pixel at the specified position on a RtgScreen.
  1936.         The BufferAdr is the starting address of the buffer the users wants
  1937.         to draw the pixel in.  The user has obtained this address using
  1938.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  1939.         the correct buffer for screens which are double or triple buffered.
  1940.  
  1941.         This function should only work for Palette mapped modes, Color is
  1942.         the Color number of the palette.
  1943.  
  1944.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  1945.  
  1946.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  1947.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  1948.         DO THE STUFF YOURSELVES.
  1949.  
  1950.    INPUTS
  1951.         RtgScreen - A handle for a valid screen previously opened by
  1952.                     this sublibrary's OpenRtgScreen() function.
  1953.         BufferAdr - The address of the memory containing the actual
  1954.                     screen graphics
  1955.         XPos - X position of the pixel the user wants to plot
  1956.         YPos - Y position of the pixel the user wants to plot
  1957.         Color - Color number
  1958.  
  1959.    SEE ALSO
  1960.         OpenRtgScreen(), WriteRtgPixelRGB(), WriteRtgPixelArray()
  1961.  
  1962.  
  1963.  
  1964. rtgmaster.library/WriteRtgPixelArray                     rtgmaster.library/WriteRtgPixelArray
  1965.  
  1966.    NAME
  1967.         WriteRtgPixelArray - writes an array of pixels to a RtgScreen
  1968.  
  1969.    SYNOPSIS
  1970.         WriteRtgPixelArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height)
  1971.                             A0         A1         A2     D0    D1   D2     D3
  1972.  
  1973.         WriteRtgPixelArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  1974.                            ULONG, ULONG)
  1975.  
  1976.    FUNCTION
  1977.         Draws an rectangular array of pixels to the specified position on a
  1978.         RtgScreen.  The BufferAdr is the starting address of the buffer the
  1979.         user wants to draw this array of pixels in.  The user has obtained
  1980.         this address using LockRtgScreen() and GetBufAdr().  The BufferAdr is
  1981.         needed to specify the correct buffer for screens which are double or
  1982.         triple buffered.
  1983.  
  1984.         This function should only work for Palette mapped modes.  The array
  1985.         consists of one byte per pixel, each byte specifying a Color number.
  1986.  
  1987.         This function is many times faster than writing each pixel seperately
  1988.         to the screen using WriteRtgPixel().
  1989.  
  1990.         Note: For compatibility with rtgAMI.library,
  1991.         Array should contain at least ((((width+15)>>4)<<4)*Height Bytes.
  1992.  
  1993.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  1994.  
  1995.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  1996.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  1997.         DO THE STUFF YOURSELVES.
  1998.  
  1999.    INPUTS
  2000.         RtgScreen - A handle for a valid screen previously opened by
  2001.                     this sublibrary's OpenRtgScreen() function.
  2002.         BufferAdr - The address of the memory containing the actual
  2003.                     screen graphics
  2004.         Array - Pointer to an array of pixels which is Width pixels wide, 
  2005.                 and Height pixels high.  Each pixel is one byte in size.
  2006.         Left - X position of the top-left of the rectangular pixel array
  2007.         Top - Y position of the top-left of the rectangular pixel array
  2008.         Width - Width of the array in pixels
  2009.         Height - Height of the array in pixels
  2010.  
  2011.    SEE ALSO
  2012.         OpenRtgScreen(), WriteRtgPixel(), WriteRtgPixelRGBArray()
  2013.  
  2014.  
  2015.  
  2016. rtgmaster.library/WriteRtgPixelRGB                         rtgmaster.library/WriteRtgPixelRGB
  2017.  
  2018.    NAME
  2019.         WriteRtgPixelRGB - plots a single pixel to a RtgScreen
  2020.  
  2021.    SYNOPSIS
  2022.         WriteRtgPixelRGB(RtgScreen, BufferAdr, XPos, YPos, Color)
  2023.                           A0         A1         D0    D1    D2
  2024.  
  2025.         WriteRtgPixelRGB(struct RtgScreen *, APTR, ULONG, ULONG, ULONG)
  2026.  
  2027.    FUNCTION
  2028.         Draws a single pixel at the specified position on a RtgScreen.
  2029.         The BufferAdr is the starting address of the buffer the users wants
  2030.         to draw the pixel in.  The user has obtained this address using
  2031.         LockRtgScreen() and GetBufAdr().  The BufferAdr is needed to specify
  2032.         the correct buffer for screens which are double or triple buffered.
  2033.  
  2034.         This function should only work for True Color modes, Color is
  2035.         a 32 bit value which specifies what Color the pixel should be.
  2036.         The layout of this 32-bit value is as follows:
  2037.  
  2038.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb        
  2039.  
  2040.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  2041.             user will set this to zero if the user doesn't want to use
  2042.             AlphaChannel.
  2043.         r = Red component (8-bits) of the 24-bit RGB value
  2044.         g = Green component (8-bits) of the 24-bit RGB value
  2045.         b = Blue component (8-bits) of the 24-bit RGB value
  2046.  
  2047.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  2048.  
  2049.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  2050.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  2051.         DO THE STUFF YOURSELVES.
  2052.  
  2053.    INPUTS
  2054.         RtgScreen - A handle for a valid screen previously opened by
  2055.                     this sublibrary's OpenRtgScreen() function.
  2056.         BufferAdr - The address of the memory containing the actual
  2057.                     screen graphics
  2058.         XPos - X position of the pixel the user wants to plot
  2059.         YPos - Y position of the pixel the user wants to plot
  2060.         Color - A 32-bit value describing the color (see above)
  2061.  
  2062.    SEE ALSO
  2063.         OpenRtgScreen(), WriteRtgPixel(), WriteRtgPixelRGBArray()
  2064.  
  2065.  
  2066.  
  2067. rtgmaster.library/WriteRtgPixelRGBArray               rtgmaster.library/WriteRtgPixelRGBArray
  2068.  
  2069.    NAME
  2070.         WriteRtgPixelRGBArray - writes an array of pixels to a RtgScreen
  2071.  
  2072.    SYNOPSIS
  2073.         WriteRtgPixelRGBArray(RtgScreen, BufferAdr, Array, Left, Top, Width, Height)
  2074.                                A0         A1         A2     D0    D1   D2     D3    
  2075.  
  2076.         WriteRtgPixelRGBArray(struct RtgScreen *, APTR, APTR, ULONG, ULONG,
  2077.                               ULONG, ULONG)
  2078.  
  2079.    FUNCTION
  2080.         Draws an rectangular array of pixels to the specified position on a
  2081.         RtgScreen.  The BufferAdr is the starting address of the buffer the
  2082.         user wants to draw this array of pixels in.  The user has obtained
  2083.         this address using LockRtgScreen() and GetBufAdr().  The BufferAdr is
  2084.         needed to specify the correct buffer for screens which are double or
  2085.         triple buffered.
  2086.  
  2087.         This function should only work for True Color modes.  The array
  2088.         consists of one longword (32-bits) per pixel, each longword specifies
  2089.         a Color in this format:
  2090.  
  2091.         %aaaaaaaa.rrrrrrrr.gggggggg.bbbbbbbb        
  2092.  
  2093.         a = AlphaChannel (8-bits) which may or may not be ignored.  The
  2094.             user will set this to zero if the user doesn't want to use
  2095.             AlphaChannel.
  2096.         r = Red component (8-bits) of the 24-bit RGB value
  2097.         g = Green component (8-bits) of the 24-bit RGB value
  2098.         b = Blue component (8-bits) of the 24-bit RGB value
  2099.  
  2100.         This function is many times faster than writing each pixel seperately
  2101.         to the screen using WriteRtgPixelRGB().
  2102.  
  2103.         THIS FUNCTION IS IMPLEMENTED WITH SUBLIBRARIES STARTING WITH VERSION 1.8
  2104.  
  2105.         DO NOT USE FOR SPEED RELEVANT STUFF. THIS FUNCTION MAY HAVE
  2106.         SOME OVERHEAD. FOR FAST OPERATIONS USE COPYRTGPIXELARRAY OR
  2107.         DO THE STUFF YOURSELVES.
  2108.  
  2109.    INPUTS
  2110.         RtgScreen - A handle for a valid screen previously opened by
  2111.                     this sublibrary's OpenRtgScreen() function.
  2112.         BufferAdr - The address of the memory containing the actual
  2113.                     screen graphics
  2114.         Array - Pointer to an array of pixels which is Width pixels wide, 
  2115.                 and Height pixels high.  Each pixel is one longword (32-bits)
  2116.                 in size.
  2117.         Left - X position of the top-left of the rectangular pixel array
  2118.         Top - Y position of the top-left of the rectangular pixel array
  2119.         Width - Width of the array in pixels
  2120.         Height - Height of the array in pixels
  2121.  
  2122.    SEE ALSO
  2123.         OpenRtgScreen(), WriteRtgPixelRGB(), WriteRtgPixelArray()
  2124.